Windows News 2010 Summer - Disc 1/WN_Ete2010_CD1.iso/Onglet5/Weezo/Weezo setup.exe/{code_appDir}/www/js/wz_dragdrop-src.js

Text File | 2010-05-19 | 71KB | 2,378 lines

/* This notice must be untouched at all times.

wz_dragdrop.js    v. 4.85
The latest version is available at
http://www.walterzorn.com
or http://www.devira.com
or http://www.walterzorn.de

Copyright (c) 2002-2003 Walter Zorn. All rights reserved.
Created 26. 8. 2002 by Walter Zorn (Web: http://www.walterzorn.com )
Last modified: 10. 2. 2006

This DHTML & Drag&Drop Library adds Drag&Drop functionality
to the following types of html-elements:
- images, even if not positioned via layers,
  nor via stylesheets or any other kind of "hard-coding"
- relatively and absolutely positioned layers (DIV elements).
Moreover, it provides extended DHTML abilities.

LICENSE: LGPL

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License (LGPL) as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

For more details on the GNU Lesser General Public License,
see http://www.gnu.org/copyleft/lesser.html
*/

/*
 * Modified by Nicolas Bruley / Peer 2 World / Weezo from march, 1st 2006
 *
 * Main changes :
 *    added windows object (see win.js and winClient.js scripts for use)
 *  added "receiver" i.e. target for drop
 *  added "elastic drag" : dragged item goes back to initial position when dropped
 *
*/

// Mouse x and y position and button state, updated by updateMousePosition() function
var mouseX,mouseY,mouseEvt,mouseVX,mouseVY,mousePosT;


// PATH TO THE TRANSPARENT 1*1 PX IMAGE (required by NS 4 as spacer)
var spacer = '/gfx/b.gif';

//Name / id of current highlighted dropTarget
var cDT=null;

// id of current highlighted receiver only Target
var currentReceiverOnlyTarget=null;

// Class of current dropTarget (unused yet)
var currentDropTargetClass=null;

// used to cancel onclick on dragged div
var dragCancelOnclick=false;

// Indicate if an object is beeing dragged
var dragInProgress=false;

// Indicate if an object is beeing resized
var resizeInProgress=false;

// min time between pick and drop to fire preDrop function
var dragMinTimeForPreDrop=0;

var winInertiaTimeout=false;

// Optional commands passed to SET_DHTML() on the html-page (g: may be applied globally, i: individually)
var CLONE            = 'C10nE';   // i  img      clone image
var COPY             = 'C0pY';    // i  img      create copies
var DETACH_CHILDREN  = 'd37aCH';  // i  lyr      detach images
var HORIZONTAL       = 'H0r1Z';   // i  img,lyr  horizontally draggable only
var MAXHEIGHT        = 'm7x8I';   // i  img,lyr  maximum height limit, "
var MAXOFFBOTTOM     = 'm7xd0wN'; // i  img,lyr  downward offset limit
var MAXOFFLEFT       = 'm7x23Ft'; // i  img,lyr  leftward offset limit
var MAXOFFRIGHT      = 'm7x0Ff8'; // i  img,lyr  rightward offset limit
var MAXOFFTOP        = 'm7xu9';   // i  img,lyr  upward offset limit
var MAXWIDTH         = 'm7xW1';   // i  img,lyr  maximum width limit, use with resizable or scalable
var MINWIDTH         = 'm1nw1';   // i  img,lyr  minimum width limit, "
var MINHEIGHT        = 'm1n8I';   // i  img,lyr  minimum height limit, "
var NO_ALT           = 'no81T';   // gi img      disable alt and title attributes
var NO_DRAG          = 'N0d4Ag';  // i  img,lyr  disable draggability
var RESET_Z          = 'r35E7z';  // gi img,lyr  reset z-index when dropped
var RESIZABLE        = 'r5IZbl';  // gi img,lyr  resizable if <ctrl> or <shift> pressed
var RESIZABLE_ONLY    = 'r5IZbl0';  // gi img,lyr  resizable without <ctrl> or <shift> pressed, not draggable
var AUTOSIZE    = 'oTo5iZ3';  // width & height not fixed
var FROZEN    = 'Fr023n';  // Item cannot be dragged or picked while frozen. Use .warm to cancel
var SCALABLE         = 'SCLbl';   // gi img,lyr  scalable           "
var SCROLL           = 'sC8lL';   // gi img,lyr  enable auto scroll functionality
var TRANSPARENT      = 'dIApHAn'; // gi img,lyr  translucent while dragged
var VERTICAL         = 'V3Rt1C';  // i  img,lyr  vertically draggable only
var INERTIA         = '1nRt14';  // i  img,lyr inertia when item dropped
var NOBOUNCE    = 'n08oVnC3'; // inertia object doesn't bounce on borders
var ROT    = 'r0T';               // object may be rotated
var DETACH         = 'd3T4cH';  // detach object from parent when draggin (to be used when object has overflow:scroll/auto/hidden)
var DETACHOFFSETX = 'd3T4cH0ff53Tx' // x-offset of detached object (use with DETACH to correct object offset when moved to parent)
var DETACHOFFSETY = 'd3T4cH0ff53Ty' // y-offset of detached object (use with DETACH to correct object offset when moved to parent)
var EPHEMERAL = '3ph3M3ra1' // Object is destroyed when dropped
var DRAGCLASS = 'Dr465Ty1E' // Add "dragged" to class when dragged
var PICKDELAY        = 'PlcKD31Ay' // Time (ms) mouse button must be kept down to pick the object
var RECEIVER         = 'R3C31vR';  // drop target
var ELASTIC            = '3LAsT1C'; // Elastic drag
var NOANIM      = 'n0An1M' // No animation when droppεng an elastic object
var NOTDROPPABLE        = 'N0tDr0dA813'; // Not droppable item (doesn't highlight drop zones)
var TRANSPARENT_RECEIVER = 'TrAn5PaRenT'; // drop target becomes transparent when dragged over.
var CTRLPLUS = 'cTRlPlV5'; // Add a plus next to the dragged item if ctrl pressed while draggin
var ISWINDOW = '15W1nD0w'; // Window
var ISICON = '15W1c0n'; // Icon
var IMGFADEIN = '1mA63FaD1n'; // Fade-in images onload

var dd_cursors = new Array(
    'c:default',
    'c:crosshair',
    'c:e-resize',
    'c:hand',
    'c:help',
    'c:move',
    'c:n-resize',
    'c:ne-resize',
    'c:nw-resize',
    'c:s-resize',
    'c:se-resize',
    'c:sw-resize',
    'c:text',
    'c:w-resize',
    'c:wait');

var dd_i = dd_cursors.length; while(dd_i--)
    eval('var CURSOR_' + (dd_cursors[dd_i].substring(2).toUpperCase().replace('-', '_')) + ' = "' + dd_cursors[dd_i] + '";');
var dd_u = "undefined";

// receiver-only objects array
function WDD(){
    this.elements = new Array(0);
    this.currentTarget=null; // Currently highlighted element
    this.currentTargetClass=''; // Currently highlighted element previous class
}
var drec=new WDD()
drec.addElt=function(obj){drec.elements[obj.id] = obj;}// Add DOM node to receiver-only list
drec.delElt=function(obj){if(obj.id && drec.elements[obj.id]) delete(drec.elements[obj.id]);} // Remove DOM node from list
drec.setScrollContainer=function(obj,item){drec.elements[obj.id].scrollContainer=item} // Function called when hovering item for over timeout ms
drec.setHighlightFunction=function(obj,func){drec.elements[obj.id].highlightFunc=func}

drec.addTimeoutFunc=function(obj,func,timeout){drec.elements[obj.id].toFunc=func;drec.elements[obj.id].timeout=timeout} // Function called when hovering item for over timeout ms
drec.computeRect = function (){for(i in drec.elements) drec.elements[i].rect=actualRect(drec.elements[i]);}
drec.highlight = function (obj){
    drec.currentTarget=obj;
    if(drec.elements[obj.id].highlightFunc) return drec.elements[obj.id].highlightFunc(obj,1);
    // Save class
    drec.currentTargetClass=obj.className;
    obj.className='dropTargetOver '+obj.className
    // Timeout function
    if(drec.elements[obj.id].toFunc){
        drec.elements[obj.id].wTimeout = W.setTimeout(drec.elements[obj.id].toFunc,drec.elements[obj.id].timeout)
    }
}
drec.unhighlight = function (){
    if(drec.currentTarget==null) return;
    // Cancel timeout function
    if(drec.currentTarget.wTimeout) {W.clearTimeout(drec.currentTarget.wTimeout); drec.currentTarget.wTimeout=false}

    // Reset class
    if(drec.currentTarget.highlightFunc) drec.currentTarget.highlightFunc(drec.currentTarget,0);
    else if(drec.currentTarget.className.substr(0,14)=='dropTargetOver') drec.currentTarget.className=drec.currentTarget.className.substr(14).trim();
    //else drec.currentTarget.className=drec.currentTargetClass;
    drec.currentTarget=null
}

function WZDD()
{
    this.elements = new Array(0);
    this.obj = null;
    this.n = navigator.userAgent.toLowerCase();
    this.db = (D.compatMode && D.compatMode.toLowerCase() != "backcompat")?
        D.documentElement
        : (D.body || null);
    this.op = !!(W.opera && D.getElementById);
    if(this.op) D.onmousedown = new Function('e',
        'if(((e = e || W.event).target || e.srcElement).tagName == "IMAGE") return false;');
    this.ie = !!(this.n.indexOf("msie") >= 0 && D.all && this.db && !this.op);
    this.ie7 = !!(this.n.indexOf("msie 7.0") >= 0 && D.all && this.db && !this.op);
    this.ie8 = !!(this.n.indexOf("msie 8.0") >= 0 && D.all && this.db && !this.op);
    this.iemac = !!(this.ie && this.n.indexOf("mac") >= 0);
    this.ie4 = !!(this.ie && !D.getElementById);
    this.n4 = !!(D.layers && typeof D.classes != dd_u);
    this.n6 = !!(typeof W.getComputedStyle != dd_u && typeof D.createRange != dd_u);
    this.w3c = !!(!this.op && !this.ie && !this.n6 && D.getElementById);
    this.ce = !!(D.captureEvents && D.releaseEvents);
    this.px = this.n4? '' : 'px';
    this.tiv = this.w3c? 40 : 10;

    this.pickDate = 0; // Date of object pick
    this.delayedPickEvt=null; // Mouse event originating drag, stored for delayed pick
    this.delayedPickTimeout=null; // Timeout used for delayed pick, and also for stating that a delayed pick is in progress
    this.dragTime= 0; // Time (ms) of drag
    this.pickMouseX = this.pickMouseY = 0; // Mouse position when picked
    this.lpDate = 0; // Last Date used for inertia animation
    this.pickX = this.pickY = 0; // x, y position of object when picked
    this.lpx = this.lpy = 0; // Last x, y positions used for inertia animation
    this.lpdx = this.lpdy = this.lpdt = this.lpda = 0; // dx, dy, dt, da used for inertia animation
    this.mPickX=0; this.mPickY=0; // Mouse coordinates on object pick
    this.mDropX=0; this.mDropY=0; // Mouse coordinates on object drop
    this.mdx=0; this.mdy=0; // Mouse move between pick and drop
}
var dd = new WZDD();

dd.Int = function (d_x, d_y)
{
    return isNaN(d_y = parseInt(d_x))? 0 : d_y;
};
dd.getWndW = function ()
{
    return dd.Int(
        (dd.db && !dd.op && !dd.w3c && dd.db.clientWidth)? dd.db.clientWidth
        : (W.innerWidth || 0)
    );
};
dd.getWndH = function ()
{
    return dd.Int(
        (dd.db && !dd.op && !dd.w3c && dd.db.clientHeight)? dd.db.clientHeight
        : (W.innerHeight || 0)
    );
};
dd.getPadding = function (){return (W.winPadding)?winPadding:{'left':0,'top':0,'right':0,'bottom':0};}
dd.getScrollX = function ()
{
    return dd.Int(W.pageXOffset || (dd.db? dd.db.scrollLeft : 0));
};
dd.getScrollY = function ()
{
    return dd.Int(W.pageYOffset || (dd.db? dd.db.scrollTop : 0));
};
dd.getPageXY = function (d_o)
{
    if(dd.n4 && d_o)
    {
        dd.x = d_o.pageX || 0;
        dd.y = d_o.pageY || 0;
    }
    else
    {
        dd.x = dd.y = 0; //global helper vars
        while(d_o)
        {
            dd.x += dd.Int(d_o.offsetLeft);
            dd.y += dd.Int(d_o.offsetTop);
            d_o = d_o.offsetParent || null;
        }
    }
};
dd.getCssXY = function (d_o)
{
    if(d_o.div)
    {
        if(dd.n4)
        {
            d_o.cssx = d_o.div.x;
            d_o.cssy = d_o.div.y;
        }
        else if(dd.ie4)
        {
            d_o.cssx = d_o.css.pixelLeft;
            d_o.cssy = d_o.css.pixelTop;
        }
        else
        {
            d_o.css.left = d_o.css.top = 0 + dd.px;
            dd.getPageXY(d_o.div);
            d_o.cssx = d_o.x - dd.x;
            d_o.cssy = d_o.y - dd.y;
            d_o.css.left = d_o.cssx + dd.px;
            d_o.css.top = d_o.cssy + dd.px;
        }
    }
    else
    {
        d_o.cssx = 0;
        d_o.cssy = 0;
    }
};
dd.getImgW = function (d_o)
{
    return d_o? dd.Int(d_o.width) : 0;
};
dd.getImgH = function (d_o)
{
    return d_o? dd.Int(d_o.height) : 0;
};
dd.getDivW = function (d_o)
{
    return dd.Int(
        dd.n4? (d_o.div? d_o.div.clip.width : 0)
        : d_o.div? (d_o.div.offsetWidth || d_o.css.pixelWidth || d_o.css.width || 0)
        : 0
    );
};
dd.getDivH = function (d_o)
{
    return dd.Int(
        dd.n4? (d_o.div? d_o.div.clip.height : 0)
        : d_o.div? (d_o.div.offsetHeight || d_o.css.pixelHeight || d_o.css.height || 0)
        : 0
    );
};
dd.getWH = function (d_o)
{
    d_o.w = dd.getDivW(d_o);
    d_o.h = dd.getDivH(d_o);
    if(d_o.css)
    {
        d_o.css.width = d_o.w + dd.px;
        d_o.css.height = d_o.h + dd.px;
        d_o.dw = dd.getDivW(d_o)-d_o.w;
        d_o.dh = dd.getDivH(d_o)-d_o.h;
        d_o.css.width = (d_o.w-d_o.dw) + dd.px;
        d_o.css.height = (d_o.h-d_o.dh) + dd.px;
    }
    else d_o.dw = d_o.dh = 0;
};
dd.getCssProp = function (d_o, d_pn6, d_pstyle, d_pn4)
{
    if(d_o && dd.n6) return ''+W.getComputedStyle(d_o, null).getPropertyValue(d_pn6);
    if(d_o && d_o.currentStyle) return ''+eval('d_o.currentStyle.'+d_pstyle);
    if(d_o && d_o.style) return ''+eval('d_o.style.'+d_pstyle);
    if(d_o && dd.n4) return ''+eval('d_o.'+d_pn4);
    return '';
};
dd.getDiv = function (d_x, d_d)
{
    d_d = d_d || document;
    if(dd.n4)
    {
        if(d_d.layers[d_x]) return d_d.layers[d_x];
        for(var d_i = d_d.layers.length; d_i--;)
        {
            var d_y = dd.getDiv(d_x, d_d.layers[d_i].document);
            if(d_y) return d_y;
        }
    }
    if(dd.ie) return d_d.all[d_x] || null;
    if(d_d.getElementById) return d_d.getElementById(d_x) || null;
    return null;
};
dd.getImg = function (d_o, d_nm, d_xy, d_w)
{
    d_w = d_w || window;
    var d_img;
    if(D.images && (d_img = d_w.D.images[d_nm]))
    {
        if(d_xy)
        {
            if(dd.n4)
            {
                dd.getPageXY(d_w);
                d_o.defx = d_img.x + dd.x;
                d_o.defy = d_img.y + dd.y;
            }
            else
            {
                dd.getPageXY(d_img);
                d_o.defx = dd.x;
                d_o.defy = dd.y;
            }
        }
        return d_img;
    }
    if(dd.n4) for(var d_i = d_w.D.layers.length; d_i--;)
    {
        var d_y = dd.getImg(d_o, d_nm, d_xy, d_w.D.layers[d_i]);
        if(d_y) return d_y;
    }
    return null;
};
dd.getParent = function (d_o, d_p)
{
    if(dd.n4)
    {
        for(d_p, d_i = dd.elements.length; d_i--;)
        {
            if(!((d_p = dd.elements[d_i]).is_image) && d_p.div && (d_p.div.D.layers[d_o.name] || d_o.oimg && d_p.div.D.images[d_o.oimg.name]))
                d_p.addChild(d_o, d_p.detach, 1);
        }
    }
    else
    {
        d_p = d_o.is_image? dd.getImg(d_o, d_o.oimg.name) : (d_o.div || null);
        while(d_p && !!(d_p = d_p.offsetParent || d_p.parentNode || null))
        {
            if(d_p.ddObj)
            {
                d_p.ddObj.addChild(d_o, d_p.ddObj.detach, 1);
                break;
            }
        }
    }
};
dd.getCmd = function (d_o, d_cmd, d_cmdStr)
{
    var d_i = d_o.id.indexOf(d_cmd), d_j,
    d_y = (d_i >= 0)*1;
    if(d_y)
    {
        d_j = d_i+d_cmd.length;
        if(d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
        d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
    }
    return d_y;
};
dd.getCmdVal = function (d_o, d_cmd, d_cmdStr, int0)
{
    var d_i = d_o.id.indexOf(d_cmd), d_j,
    d_y = (d_o.id.indexOf(d_cmd) >= 0)? dd.Int(d_o.id.substring(d_o.id.indexOf(d_cmd)+d_cmd.length)) : int0? -1 : 0;
    if(!int0 && d_y || int0 && d_y >= 0)
    {
        d_j = d_i+d_cmd.length+(""+d_y).length;
        if(d_cmdStr) d_o.cmd += d_o.id.substring(d_i, d_j);
        d_o.id = d_o.id.substring(0, d_i) + d_o.id.substring(d_j);
    }
    return d_y;
};
dd.addElt = function (d_o, d_p)
{
    dd.elements[d_o.name] = dd.elements[d_o.index = dd.elements.length] = d_o;
    if(d_p) d_p.copies[d_o.name] = d_p.copies[d_p.copies.length] = d_o;
};
dd.mkWzDom = function ()
{
    var d_o, d_i = dd.elements.length; while(d_i--) dd.getParent(dd.elements[d_i]);
    d_i = dd.elements.length; while(d_i--)
    {
        d_o = dd.elements[d_i];
        if(d_o.children && !d_o.parent)
        {
            var d_j = d_o.children.length; while(d_j--)
                d_o.children[d_j].setZ(d_o.z+d_o.children[d_j].z, 1);
        }
    }
};
dd.addProps = function (d_o)
{
    var d_i, d_c;
    if(d_o.is_image)
    {
        d_o.div = dd.getDiv(d_o.id);
        d_o.css = (d_o.div && typeof d_o.div.style != dd_u)? d_o.div.style : null;
        d_o.nimg = (dd.n4 && d_o.div)? d_o.div.D.images[0] : (D.images[d_o.id+"NI1m6G"] || null);
        if(!d_o.noalt && !dd.noalt && d_o.nimg && d_o.oimg)
        {
            d_o.nimg.alt = d_o.oimg.alt || '';
            if(d_o.oimg.title) d_o.nimg.title = d_o.oimg.title;
        }
        d_o.bgColor = '';
    }
    else
    {
        d_o.bgColor = dd.getCssProp(d_o.div, 'background-color','backgroundColor','bgColor').toLowerCase();
        if(dd.n6 && d_o.div)
        {
            if((d_c = d_o.bgColor).indexOf('rgb') >= 0)
            {
                d_c = d_c.substring(4, d_c.length-1).split(',');
                d_o.bgColor = '#';
                for(d_i = 0; d_i < d_c.length; d_i++) d_o.bgColor += parseInt(d_c[d_i]).toString(0x10);
            }
            else d_o.bgColor = d_c;
        }
    }
    if(dd.scalable) d_o.scalable = d_o.resizable^1;
    else if(dd.resizable) d_o.resizable = d_o.scalable^1;
    d_o.setZ(d_o.defz);
    d_o.cursor = d_o.cursor || dd.cursor || 'auto';
    d_o._setCrs(d_o.nodrag? 'auto' : d_o.cursor);
    d_o.diaphan = d_o.diaphan || dd.diaphan || 0;
    d_o.opacity = 1.0;
    d_o.visible = true;
};
dd.initz = function ()
{
    if(!(dd && (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c))) return;
    else if(dd.n6 || dd.ie || dd.op || dd.w3c) dd.recalc(1);
    var d_drag = (D.onmousemove == DRAG),
    d_resize = (D.onmousemove == RESIZE);
    if(dd.loadFunc) dd.loadFunc();
    if(d_drag) dd.setMovHdl(DRAG);
    else if(d_resize) dd.setMovHdl(RESIZE);
    if(d_drag || d_resize) dd.setUpHdl(DROP);
    dd.setDwnHdl(PICK);
};
dd.finlz = function ()
{
    if(dd.ie && dd.elements)
    {
        var d_i = dd.elements.length; while(d_i--)
            dd.elements[d_i].del();
    }
    if(dd.uloadFunc) dd.uloadFunc();
};

dd.setDwnHdl = function (d_x)
{
    if(D.onmousedown != d_x)
    {
        dd.downFunc = D.onmousedown;
        D.onmousedown = d_x;
        D.ontouchstart = d_x;
    }
};
dd.setMovHdl = function (d_x)
{
    if(D.onmousemove != d_x)
    {
        D.onmousemove = d_x;
        D.ontouchmove= d_x;
    }
};
dd.setUpHdl = function (d_x)
{
    if(D.onmouseup != d_x)
    {
        dd.upFunc = D.onmouseup;
        D.onmouseup = d_x;
        D.ontouchend = d_x;
    }
};
dd.setKDwnHdl = function (d_x)
{
    if(D.onkeydown != d_x)
    {
        dd.kDwnFunc = D.onkeydown;
        D.onkeydown = d_x;
    }
};
dd.setKUpHdl = function (d_x)
{
    if(D.onkeyup != d_x)
    {
        dd.kUpFunc = D.onkeyup;
        D.onkeyup = d_x;
    }
};

dd.evt = function (d_e)
{
    // iPhone
    if(d_e && d_e.touches){
        this.e=d_e;
        this.button=this.but=d_e['type']=="touchend"?0:1;
        var t=d_e.touches[0];
        if(t){
            this.src=t?t.target:null;
            this.x=t.clientX;
            this.y=t.clientY;
        }
        else{
            this.src=d_e.target;
            this.x=mouseX;
            this.y=mouseY;
        }
        this.modifKey=false;
    }
    // Desktop browsers
    else{
        this.but = (this.e = d_e || W.event).which || this.e.button || 0;
        this.button = (this.e.type == 'mousedown')? this.but
            : (dd.e && dd.e.button)? dd.e.button
            : 0;
        this.src = this.e.target || this.e.srcElement || null;

        this.x = dd.Int(this.e.pageX || this.e.clientX || 0);
        this.y = dd.Int(this.e.pageY || this.e.clientY || 0);
        if(dd.ie)
        {
            this.x += dd.getScrollX() - (dd.ie && !dd.iemac)*1;
            this.y += dd.getScrollY() - (dd.ie && !dd.iemac)*1;
        }
        this.modifKey = this.e.modifiers? this.e.modifiers&Event.SHIFT_MASK : (this.e.shiftKey || false);
        this.ctrlKey = this.e.modifiers? this.e.modifiers&Event.CONTROL_MASK : (this.e.ctrlKey || false);
    }
    this.src.tag = ("" + (this.src.tagName || this.src)).toLowerCase();
};

// Script load monitoring
if(W.lFunc) lFunc('wz_dragdrop',25);

dd.getEventTarget = function (d_e, d_s, d_n)
{
    d_e = d_e || W.event;
    if(d_e && (d_s = d_e.target || d_e.srcElement || null) != null)
    {
        if(null != (d_n = d_s.id || d_s.name || null))
        {
            if(d_n.indexOf("dIi15vNI1m6G") == d_n.length-12)
                return dd.elements[d_n.substring(0, d_n.length-12)] || null;
            if(d_n.indexOf("dIi15v") == d_n.length-6)
                return dd.elements[d_n.substring(0, d_n.length-6)] || null;
            return dd.elements[d_n] || null;
        }
    }
    return null;
};
dd.recalc = function (d_x)
{
    var d_o, d_i = dd.elements.length; while(d_i--)
    {
        if(!(d_o = dd.elements[d_i]).is_image && d_o.div)
        {
            dd.getWH(d_o);
            if(d_o.div.pos_rel)
            {
                dd.getPageXY(d_o.div);
                var d_dx = dd.x - d_o.x, d_dy = dd.y - d_o.y;
                d_o.defx += d_dx;
                d_o.x += d_dx;
                d_o.defy += d_dy;
                d_o.y += d_dy;
                var d_p, d_j = d_o.children.length; while(d_j--)
                {
                    if(!(d_p = d_o.children[d_j]).detached && (d_o != d_p.defparent || !(d_p.is_image && dd.getImg(d_p, d_p.oimg.name, 1))))
                    {
                        d_p.defx += d_dx;
                        d_p.defy += d_dy;
                        d_p.moveBy(d_dx, d_dy);
                    }
                }
            }
        }
        else if(d_o.is_image && !dd.n4)
        {
            if(dd.n6 && d_x && !d_o.defw) d_o.resizeTo(d_o.defw = dd.getImgW(d_o.oimg), d_o.defh = dd.getImgH(d_o.oimg));
            var d_defx = d_o.defx, d_defy = d_o.defy;
            if(!(d_o.parent && d_o.parent != d_o.defparent) && (d_x || !d_o.detached || d_o.horizontal || d_o.vertical) && dd.getImg(d_o, d_o.oimg.name, 1))
                d_o.moveBy(d_o.defx-d_defx, d_o.defy-d_defy);
        }
    }
};
dd.recalcItem = function (d_i){
    if(d_i) d_o=dd.elements[d_i]; else d_o=dd.obj;
    if(!d_o.is_image && d_o.div)
    {
        dd.getWH(d_o);
        if(d_o.div.pos_rel)
        {
            dd.getPageXY(d_o.div);
            var d_dx = dd.x - d_o.x, d_dy = dd.y - d_o.y;
            d_o.defx += d_dx;
            d_o.x += d_dx;
            d_o.defy += d_dy;
            d_o.y += d_dy;
            var d_p, d_j = d_o.children.length; while(d_j--)
            {
                if(!(d_p = d_o.children[d_j]).detached && (d_o != d_p.defparent || !(d_p.is_image && dd.getImg(d_p, d_p.oimg.name, 1))))
                {
                    d_p.defx += d_dx;
                    d_p.defy += d_dy;
                    d_p.moveBy(d_dx, d_dy);
                }
            }
        }
    }
    else if(d_o.is_image && !dd.n4)
    {
        if(dd.n6 && !d_o.defw) d_o.resizeTo(d_o.defw = dd.getImgW(d_o.oimg), d_o.defh = dd.getImgH(d_o.oimg));
        var d_defx = d_o.defx, d_defy = d_o.defy;
        if(!(d_o.parent && d_o.parent != d_o.defparent) && (!d_o.detached || d_o.horizontal || d_o.vertical) && dd.getImg(d_o, d_o.oimg.name, 1))
            d_o.moveBy(d_o.defx-d_defx, d_o.defy-d_defy);
    }
}
dd.elasticAnim = function (objName){
    var obj=dd.elements[objName];
    if(Math.pow(obj.defx-obj.x,2)+Math.pow(obj.defy-obj.y,2)<19){
        obj.moveTo(obj.defx,obj.defy);
        obj.released();
    }
    else{
        obj.moveTo(Math.floor((3*obj.x+obj.defx)/4),Math.floor((3*obj.y+obj.defy)/4));
        setTimeout('dd.elasticAnim("'+objName+'")',1);
    }
}
function WINSZ(d_x)
{
    if(d_x)
    {
        if(dd.n4)
        {
            dd.iW = innerWidth;
            dd.iH = innerHeight;
        }
        W.onresize = new Function('WINSZ();');
        return;
    }
    else if(dd.n4 && (innerWidth != dd.iW || innerHeight != dd.iH)) location.reload();
    else if(!dd.n4) setTimeout('dd.recalc()', 0xa);
    my_winResize();
}
WINSZ(1);

function DDObj(d_o, d_i)
{
    this.id = d_o;
    this.cmd = '';
    this.cpy_n = dd.getCmdVal(this, COPY);
    this.maxoffb = dd.getCmdVal(this, MAXOFFBOTTOM, 0, 1);
    this.maxoffl = dd.getCmdVal(this, MAXOFFLEFT, 0, 1);
    this.maxoffr = dd.getCmdVal(this, MAXOFFRIGHT, 0, 1);
    this.maxofft = dd.getCmdVal(this, MAXOFFTOP, 0, 1);

    this.receiver = dd.getCmd(this, RECEIVER);
    this.elastic = dd.getCmd(this, ELASTIC);
    this.noAnim = dd.getCmd(this, NOANIM);
    this.notDroppable = dd.getCmd(this, NOTDROPPABLE);
    this.transparentReceiver = dd.getCmd(this, TRANSPARENT_RECEIVER);
    this.ctrlPlus = dd.getCmd(this, CTRLPLUS);

    var d_j = dd_cursors.length; while(d_j--)
        if(dd.getCmd(this, dd_cursors[d_j], 1)) this.cursor = dd_cursors[d_j].substring(2);
    this.clone = dd.getCmd(this, CLONE, 1);
    this.detach = dd.getCmd(this, DETACH_CHILDREN);
    this.scalable = dd.getCmd(this, SCALABLE, 1);
    this.horizontal = dd.getCmd(this, HORIZONTAL);
    this.noalt = dd.getCmd(this, NO_ALT, 1);
    this.nodrag = dd.getCmd(this, NO_DRAG);
    this.scroll = dd.getCmd(this, SCROLL, 1);
    this.resizable = dd.getCmd(this, RESIZABLE, 1);
    this.autoSize = dd.getCmd(this, AUTOSIZE, 1);
    this.frozen = dd.getCmd(this, FROZEN, 1);
    this.dragClass = dd.getCmd(this, DRAGCLASS, 1);
    this.resizableOnly = dd.getCmd(this, RESIZABLE_ONLY, 1);
    if(this.resizableOnly) this.resizable=true;
    this.inertia = dd.getCmd(this, INERTIA, 1);
    this.bounce = !dd.getCmd(this, NOBOUNCE, 1);
    this.rot = dd.getCmd(this, ROT, 1);
    this.angle=0;
    this.ephemeral = dd.getCmd(this, EPHEMERAL, 1);

    this.detachFromParent = dd.getCmd(this, DETACH, 1);
    this.detachOffsetX = dd.getCmdVal(this, DETACHOFFSETX, 0, 0);
    this.detachOffsetY = dd.getCmdVal(this, DETACHOFFSETY, 0, 0);
    this.offsetX = 0; // used when object is in a overflow:scroll node, and detachFromParent is set
    this.offsetY = 0; // used when object is in a overflow:scroll node, and detachFromParent is set

    this.pickDelay = dd.getCmdVal(this, PICKDELAY, 0, 0);

    this.re_z = dd.getCmd(this, RESET_Z, 1);
    this.diaphan = dd.getCmd(this, TRANSPARENT, 1);
    this.vertical = dd.getCmd(this, VERTICAL);
    this.maxw = dd.getCmdVal(this, MAXWIDTH, 1, 1);
    this.minw = Math.abs(dd.getCmdVal(this, MINWIDTH, 1, 1));
    this.maxh = dd.getCmdVal(this, MAXHEIGHT, 1, 1);
    this.minh = Math.abs(dd.getCmdVal(this, MINHEIGHT, 1, 1));
    this.pickFunc = this.dragFunc = this.resizeFunc = this.dropFunc = this.dropFuncInertia = null;this.scrollContainer=null;

    if(this.id.indexOf('DRAGFUNC(')>=0){
        this.dragFunc=this.id.substr(this.id.indexOf('DRAGFUNC(')+9).substr(0,this.id.indexOf(')')-1);
        this.dragFunc=this.dragFunc.substr(0,this.dragFunc.indexOf(')'));
        this.id=this.id.substr(0,this.id.indexOf('DRAGFUNC('))+this.id.substr(this.id.indexOf('DRAGFUNC(')+this.dragFunc.length+11)
    }

    if(dd.getCmd(this, ISWINDOW)){
        this.isWindow = 1;
        this.minw = winMinW; this.minh = winMinH;
        this.winState='normal';
        this.resizeDir='';
        this.resizeIfPick=false;
    }
    else this.isWindow = false;

    if(dd.getCmd(this, ISICON)) this.isIcon = true; else this.isIcon = false;
    if(dd.getCmd(this, IMGFADEIN)) this.imgFadeIn = true;

    this.name = this.id + (d_i || '');
    this.oimg = dd.getImg(this, this.id, 1);
    this.is_image = !!this.oimg;

    this.copies = new Array();
    this.children = new Array();
    this.parent = this.original = null;
    if(this.oimg)
    {
        this.id = this.name + "dIi15v";
        this.w = dd.getImgW(this.oimg);
        this.h = dd.getImgH(this.oimg);
        this.dw = this.dh = 0;
        this.defz = dd.Int(dd.getCssProp(this.oimg, 'z-index','zIndex','zIndex')) || 1;
        this.defsrc = this.src = this.oimg.src;
        this.htm = '<img name="' + this.id + 'NI1m6G"'+
            ' src="' + this.oimg.src + '" '+ 'width="' + this.w + '" height="' + this.h + '"'
        if(this.imgFadeIn) {
            this.htm+='style="visibility:hidden" onload="fade(this)"';
        }
        this.htm+='>';
        this.t_htm = '<div id="' + this.id +
            '" style="position:absolute;'+
            'left:' + (this.cssx = this.x = this.defx) + 'px;'+
            'top:' + (this.cssy = this.y = this.defy) + 'px;'+
            'width:' + this.w + 'px;'+
            'height:' + this.h + 'px;">'+
            this.htm + '</div>';
    }
    else
    {
        if(!!(this.div = dd.getDiv(this.id)) && typeof this.div.style != dd_u) this.css = this.div.style;
        if(this.div && this.div.id && this.div.id=='mDlList') this.css = '';
        dd.getWH(this);
        if(this.div)
        {
            this.div.ddObj = this;
            this.div.pos_rel = ("" + (this.div.parentNode? this.div.parentNode.tagName : this.div.parentElement? this.div.parentElement.tagName : '').toLowerCase().indexOf('body') < 0);
        }
        dd.getPageXY(this.div);
        this.defx = this.x = dd.x;
        this.defy = this.y = dd.y;
        dd.getCssXY(this);
        this.defz = dd.Int(dd.getCssProp(this.div, 'z-index','zIndex','zIndex'));
    }
    this.defw = this.w || 0;
    this.defh = this.h || 0;
}
DDObj.prototype.setPickFunc = function (d_x){this.pickFunc = d_x;};
DDObj.prototype.setDragFunc = function (d_x){this.dragFunc = d_x;};
DDObj.prototype.setResizeFunc = function (d_x){this.resizeFunc = d_x;};
DDObj.prototype.setDropFunc = function (d_x){this.dropFunc = d_x;};
DDObj.prototype.setDropFuncInertia = function (d_x){this.dropFuncInertia = d_x;};
// Called when done with dragged object
DDObj.prototype.setReleasedFunc = function (d_x){this.releasedFunc = d_x;};
DDObj.prototype.setScrollContainer = function (d_x){this.scrollContainer = d_x;};
DDObj.prototype.moveBy = function (d_x, d_y, d_kds, d_o){
    if(!this.div) return;
    this.x += (d_x = dd.Int(d_x));
    this.y += (d_y = dd.Int(d_y));
    if(!d_kds || this.is_image || this.parent != this.defparent)
    {
        (d_o = this.css || this.div).left = (this.cssx += d_x) + dd.px;
        d_o.top = (this.cssy += d_y) + dd.px;
    }
    var d_i = this.children.length; while(d_i--)
    {
        if(!(d_o = this.children[d_i]).detached) d_o.moveBy(d_x, d_y, 1);
        d_o.defx += d_x;
        d_o.defy += d_y;
    }
};

DDObj.prototype.moveTo = function (d_x, d_y)
{
    this.moveBy(((d_x===false)?0:dd.Int(d_x)-this.x), ((d_y===false)?0:dd.Int(d_y)-this.y));
};

// Rotate object to d_r degrees
DDObj.prototype.rotTo = function (a)
{
    var s=this.div.style;
    s.WebkitTransform=s.MozTransform=s.OTransform='rotate('+(-a)+'deg)';
    this.angle=a;
};

// Rotate object by d_r degrees
DDObj.prototype.rotBy = function (da){this.rotTo(this.angle+da)};


// Launch item in given direction (common values: 0.5 < |vx/vy| < 2)
DDObj.prototype.launch=function (vx,vy){
    if(dd.obj==this && this.isLaunched){
        dd.obj.lpdx+=vx+((dd.obj.lpdx*vx>0)?vx:0)
        dd.obj.lpdy+=vy+((dd.obj.lpdy*vy>0)?vy:0)
    }
    else{
        dd.obj=this;
        dd.obj.pickDate=dd.obj.lpDate=(new Date()).getTime();
        dd.obj.pickX=dd.obj.lpx=dd.obj.x;dd.obj.pickY=dd.obj.lpy=dd.obj.y;dd.obj.lpdx=vx;dd.obj.lpdy=vy;dd.obj.lpdt=1;
        my_DragFunc(dd.obj.index);
    }
}

DDObj.prototype.hide = function (d_m, d_o, d_p)
{
    if(this.div && this.visible)
    {
        d_p = this.css || this.div;
        if(d_m && !dd.n4)
        {
            this.display = dd.getCssProp(this.div, "display", "display", "display");
            if(this.oimg)
            {
                this.oimg.display = dd.getCssProp(this.oimg, "display", "display", "display");
                this.oimg.style.display = "none";
            }
            d_p.display = "none";
            dd.recalc();
        }
        else d_p.visibility = "hidden";
    }
    this.visible = false;
    var d_i = this.children.length; while(d_i--)
        if(!(d_o = this.children[d_i]).detached) d_o.hide(d_m);
};
DDObj.prototype.show = function (d_o, d_p)
{
    if(this.div)
    {
        d_p = this.css || this.div;
        if(d_p.display && d_p.display == "none")
        {
            d_p.display = this.display || "block";
            if(this.oimg) this.oimg.style.display = this.oimg.display || "inline";
            dd.recalc();
        }
        else d_p.visibility = "visible";
    }
    this.visible = true;
    var d_i = this.children.length; while(d_i--)
        if(!(d_o = this.children[d_i]).detached) d_o.show();
};
DDObj.prototype.resizeTo = function (d_w, d_h, d_o)
{
    if(!this.div) return;
    if(d_w===false) d_w=this.w;
    if(d_h===false) d_h=this.h;
    if(isNaN(d_w) && (d_w=='auto' || d_w.substr(d_w.length-1,1)=='%' || d_w.substr(d_w.length-2,2)=='em')) wPx=false;
    else {d_w = (this.w = dd.Int(d_w))-this.dw;    wPx=true;}
    if(isNaN(d_h) && (d_h=='auto' || d_h.substr(d_h.length-1,1)=='%' || d_h.substr(d_h.length-2,2)=='em')) hPx=false;
    else {d_h = (this.h = dd.Int(d_h))-this.dh;    hPx=true;}
    if(dd.n4)
    {
        this.div.resizeTo(d_w, d_h);
        if(this.is_image)
        {
            this.write('<img src="' + this.src + '" width="' + d_w + '" height="' + d_h + '">');
            (this.nimg = this.div.D.images[0]).src = this.src;
        }
    }
    //else if(typeof this.css.pixelWidth != dd_u) // modified on 2007/07/13
    else if(wPx && hPx && typeof this.css.pixelWidth != dd_u)
    {
        this.css.pixelWidth = d_w;
        this.css.pixelHeight = d_h;
        if(this.is_image)
        {
            (d_o = this.nimg.style).pixelWidth = d_w;
            d_o.pixelHeight = d_h;
        }
    }
    else
    {
        this.css.width  = d_w + ((wPx)?dd.px:'');
        this.css.height = d_h + ((hPx)?dd.px:'');
        if(this.is_image)
        {
            (d_o = this.nimg).width = d_w;
            d_o.height = d_h;
            if(!d_o.complete) d_o.src = this.src;
        }
    }
};
DDObj.prototype.resizeBy = function (d_dw, d_dh)
{
    var rw=((d_dw=='auto')?'auto':this.w+dd.Int(d_dw));
    var rh=((d_dh=='auto')?'auto':this.h+dd.Int(d_dh));
    this.resizeTo(rw, rh);
};
DDObj.prototype.setMinHeight= function (d_dh) {this.minh=d_dh;if(this.h<d_dh) this.resizeTo('auto',d_dh);};
DDObj.prototype.setMaxHeight= function (d_dh) {this.maxh=d_dh;if(this.h>d_dh) this.resizeTo('auto',d_dh);};
DDObj.prototype.setMinWidth= function (d_dw) {this.minw=d_dw;if(this.w<d_dw) this.resizeTo(d_dw,'auto');};
DDObj.prototype.setMaxWidth= function (d_dw) {this.maxw=d_dw;if(this.w>d_dw) this.resizeTo(d_dw,'auto');};
DDObj.prototype.setInertia= function (d_dw) {this.inertia=d_dw;};
DDObj.prototype.freeze= function () {this.frozen=true;};
DDObj.prototype.warm= function () {this.frozen=false;};

DDObj.prototype.swapImage = function (d_x, d_cp)
{
    if(!this.nimg) return;
    this.nimg.src = d_x;
    this.src = this.nimg.src;
    if(d_cp)
    {
        var d_i = this.copies.length; while(d_i--)
            this.copies[d_i].src = this.copies[d_i].nimg.src = this.nimg.src;
    }
};
DDObj.prototype.setBgColor = function (d_x)
{
    if(dd.n4 && this.div) this.div.bgColor = d_x;
    else if(this.css) this.css.background = d_x;
    this.bgColor = d_x;
};
DDObj.prototype.write = function (d_x, d_o)
{
    this.text = d_x;
    if(!this.div) return;
    if(dd.n4)
    {
        (d_o = this.div.document).open();
        d_o.write(d_x);
        d_o.close();
        dd.getWH(this);
    }
    else
    {
        this.css.height = 'auto';
        this.div.innerHTML = d_x;
        if(!dd.ie4) dd.recalc();
        if(dd.ie4 || dd.n6) setTimeout('dd.recalc();', 0); // n6.0: recalc twice
    }
};
DDObj.prototype.copy = function (d_n, d_p, d_b)
{
    if(!this.oimg) return;
    d_b = (dd.ie && D.all.tags('body'))? D.all.tags('body')[0] : D.getElementsByTagName? (D.getElementsByTagName('body')[0] || dd.db) : dd.db;
    d_n = d_n || 1;
    while(d_n--)
    {
        var d_l = this.copies.length,
        d_o = new DDObj(this.name+this.cmd, d_l+1);
        if(dd.n4)
        {
            d_o.id = (d_p = new Layer(d_o.w)).name;
            d_p.clip.height = d_o.h;
            d_p.visibility = 'show';
            (d_p = d_p.document).open();
            d_p.write(d_o.htm);
            d_p.close();
        }
        else if(d_b && d_b.insertAdjacentHTML) d_b.insertAdjacentHTML("AfterBegin", d_o.t_htm);
        else if(D.createElement && d_b && d_b.appendChild)
        {
            d_b.appendChild(d_p = D.createElement("dIi15v"));
            d_p.innerHTML = d_o.htm;
            d_p.id = d_o.id;
            d_p.style.position = 'absolute';
            d_p.style.width = d_o.w + 'px';
            d_p.style.height = d_o.h + 'px';
        }
        else if(d_b && d_b.innerHTML) d_b.innerHTML += d_o.t_htm;
        d_o.defz = this.defz+1+d_l;
        dd.addProps(d_o);
        d_o.original = this;
        dd.addElt(d_o, this);
        if(this.parent)
        {
            this.parent.addChild(d_o, this.detached);
            d_o.defparent = this.defparent;
        }
        d_o.moveTo(d_o.defx = this.defx, d_o.defy = this.defy);
        if(dd.n4) d_o.defsrc = d_o.src = this.defsrc;
        d_o.swapImage(this.src);
    }
};
DDObj.prototype.addChild = function (d_kd, detach, defp)
{
    if(typeof d_kd != "object") d_kd = dd.elements[d_kd];
    if(d_kd.parent && d_kd.parent == this || d_kd == this || !d_kd.is_image && d_kd.defparent && !defp) return;

    this.children[this.children.length] = this.children[d_kd.name] = d_kd;
    d_kd.detached = detach || 0;
    if(defp) d_kd.defparent = this;
    else if(this == d_kd.defparent && d_kd.is_image) dd.getImg(this, d_kd.oimg.name, 1);
    if(!d_kd.defparent || this != d_kd.defparent)
    {
        d_kd.defx = d_kd.x;
        d_kd.defy = d_kd.y;
    }
    if(!detach)
    {
        d_kd.defz = d_kd.defz+this.defz-(d_kd.parent? d_kd.parent.defz : 0)+(!d_kd.is_image*1);
        d_kd.setZ(d_kd.z+this.z-(d_kd.parent? d_kd.parent.z : 0)+(!d_kd.is_image*1), 1);
    }
    if(d_kd.parent) d_kd.parent._removeChild(d_kd, 1);
    d_kd.parent = this;
};
DDObj.prototype._removeChild = function (d_kd, d_newp)
{
    if(typeof d_kd != "object") d_kd = this.children[d_kd];
    var d_oc = this.children, d_nc = new Array();
    for(var d_i = 0; d_i < d_oc.length; d_i++)
        if(d_oc[d_i] != d_kd) d_nc[d_nc.length] = d_oc[d_i];
    this.children = d_nc;
    d_kd.parent = null;
    if(!d_newp)
    {
        d_kd.detached = d_kd.defp = 0;
        if(d_kd.is_image) dd.getImg(d_kd, d_kd.oimg.name, 1);
    }
};
DDObj.prototype.attachChild = function (d_kd)
{
    (d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 0;
    d_kd.setZ(d_kd.defz + this.z-this.defz, 1);
};
DDObj.prototype.detachChild = function (d_kd)
{
    (d_kd = (typeof d_kd != "object")? this.children[d_kd]: d_kd).detached = 1;
};
DDObj.prototype.setZ = function (d_x, d_kds, d_o)
{
    if(d_kds)
    {
        var d_dz = d_x-this.z,
        d_i = this.children.length; while(d_i--)
            if(!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.z+d_dz, 1);
    }
    dd.z = Math.max(dd.z, this.z = this.div? ((this.css || this.div).zIndex = d_x) : 0);
    if(this.z>0) dd.zMin = Math.max(0,Math.min(dd.zMin, this.z));
};
DDObj.prototype.maximizeZ = function ()
{
    this.setZ(dd.z+1, 1);
};
DDObj.prototype.minimizeZ = function ()
{
    this.setZ(Math.max(0,dd.zMin-1), 1);
};
DDObj.prototype._resetZ = function (d_o)
{
    if(this.re_z || dd.re_z)
    {
        this.setZ(this.defz);
        var d_i = this.children.length; while(d_i--)
            if(!(d_o = this.children[d_i]).detached) d_o.setZ(d_o.defz);
    }
};
// Set opacity (0-1)
DDObj.prototype.setOpacity = function (d_x)
{
    this.opacity = d_x;
    this._setOpaRel(1.0, 1);
};
DDObj.prototype._setOpaRel = function (d_x, d_kd, d_y, d_o)
{
    if(this.css && (this.diaphan || d_kd))
    {
        d_y = this.opacity*d_x;
        if(typeof this.css.MozOpacity != dd_u) this.css.MozOpacity = d_y;
        else if(typeof this.css.filter != dd_u){
            if(typeof this.div.style.opacity!=dd_u) this.div.style.opacity=d_y; // Weezo mod for opera 9.5
            else this.css.filter = "Alpha(opacity="+parseInt(100*d_y)+")";
        }
        else this.css.opacity = d_y;
        var d_i = this.children.length; while(d_i--)
            if(!(d_o = this.children[d_i]).detached) d_o._setOpaRel(d_x, 1);
    }
};
DDObj.prototype.setCursor = function (d_x)
{
    this._setCrs(this.cursor = (d_x.indexOf('c:')+1)? d_x.substring(2) : d_x);
};
DDObj.prototype._setCrs = function (d_x)
{
    if(this.css) this.css.cursor = ((!dd.ie || dd.iemac) && d_x == 'hand')? 'pointer' : d_x;
};
DDObj.prototype.setDraggable = function (d_x)
{
    this.nodrag = !d_x*1;
    this._setCrs(d_x? this.cursor : 'auto');
};
DDObj.prototype.setResizable = function (d_x)
{
    this.resizable = d_x*1;
    if(d_x) this.scalable = 0;
};
DDObj.prototype.setScalable = function (d_x)
{
    this.scalable = d_x*1;
    if(d_x) this.resizable = 0;
};
DDObj.prototype.getEltBelow = function (d_ret, d_x, d_y)
{
    var d_o, d_cmp = -1, d_i = dd.elements.length; while(d_i--)
    {
        d_o = dd.elements[d_i];
        d_x = d_o.x-this.w/2-((d_o.scrollContainer)?d_o.scrollContainer.scrollLeft:0);
        d_y = d_o.y-this.h/2-((d_o.scrollContainer)?d_o.scrollContainer.scrollTop:0);
        if(d_o.visible && d_o.z < this.z && this.x >= d_x && this.x <= d_x+d_o.w && this.y >= d_y && this.y <= d_y+d_o.h)
        {
            if(d_o.z > d_cmp)
            {
                //Remove items scrolled out of view
                if(d_o.scrollContainer && (d_o.div.offsetTop-d_o.scrollContainer.scrollTop<0 || d_o.div.offsetTop-d_o.scrollContainer.scrollTop>d_o.scrollContainer.offsetHeight)){}
                else{
                    d_cmp = d_o.z;
                    d_ret = d_o;
                    return d_ret;
                }
            }
        }
    }
    //return d_ret;
};
// Time elapsed since pick (ms)
DDObj.prototype.pickTime = function (){return wl.chrono.microtime() - this.pickDate;}


// Script load monitoring
if(W.lFunc) lFunc('wz_dragdrop',25);

/**
 * @desc Get receiver-only object below object
 * @param boolean setRec: true to recompute objects positions, false to use stored position
 * @param boolean useMousePos: true to use mouse position instead of objects borders
 * @return DOM node (or null if not found)
 */
DDObj.prototype.receiverOnlyGetEltBelow = function (computePositions, useMousePos)
{
    if(computePositions==undefined || computePositions) drec.computeRect();
    if(useMousePos==undefined) useMousePos=1;
    var aol; var aot=0; var isP; var o; var rect;
    var found=new Array();
    var sdx; var sdy; var rectx; var recty;

    // Browse elements to find elements below
    for(i in drec.elements) {

        var ob=drec.elements[i];
        if(!ob.rect) ob.rect=actualRect(ob);
        rectx=ob.rect.x-((ob.scrollContainer)?ob.scrollContainer.scrollLeft:0);
        recty=ob.rect.y-((ob.scrollContainer)?ob.scrollContainer.scrollTop:0);

        if(useMousePos)
            if(rectx<=mouseX&&rectx+ob.rect.w>=mouseX&&recty<=mouseY&&recty+ob.rect.h>=mouseY) found[found.length]=ob;
        else
            if(rectx<=this.x+this.w && rectx+ob.rect.w>=this.x&&recty<=this.y+this.h&&recty+ob.rect.h>=this.y) found[found.length]=ob;
    }
    // In results, search 1st element with no child
    for(i=found.length-1;i>=0;i--){
        if(i==0) return found[0];
        else{
            for(o=i-1;o>=0;o--) {
                if(isParent(found[i],found[o])) break;
            }
            if(o<0) return found[i];
        }
    }
    return null;
}

DDObj.prototype.del = function (no_recalc)
{
    var d_i;
    if(this.parent && this.parent._removeChild) this.parent._removeChild(this);
    if(this.original)
    {
        this.hide();
        if(this.original.copies)
        {
            d_os = new Array();
            for(d_i = 0; d_i < this.original.copies.length; d_i++)
                if((d_o = this.original.copies[d_i]) != this) d_os[d_o.name] = d_os[d_os.length] = d_o;
            this.original.copies = d_os;
        }
    }
    else if(this.is_image)
    {
        this.hide();
        if(this.oimg)
        {
          if(dd.n4) this.oimg.src = this.defsrc;
          else this.oimg.style.visibility = 'visible';
        }
    }
    else if(this.moveTo)
    {
        if(this.css) this.css.cursor = 'default';
        this.moveTo(this.defx, this.defy);
        this.resizeTo(this.defw, this.defh);
    }
    d_os = new Array();
    for(d_i = 0; d_i < dd.elements.length; d_i++)
    {
        if((d_o = dd.elements[d_i]) != this) d_os[d_o.name] = d_os[d_o.index = d_os.length] = d_o;
        else d_o._free();
    }
    dd.elements = d_os;
    if(!dd.n4 && (no_recalc==undefined || no_recalc===false)) dd.recalc();
};
DDObj.prototype.released = function (){
    if(this.releasedFunc) this.releasedFunc(this);
    if(this.ephemeral) this.del(1);
}

DDObj.prototype._free = function ()
{
    for(var d_i in this)
        this[d_i] = null;
    dd.elements[this.name] = null;
};
dd.n4RectVis = function (vis)
{
    for(var d_i = 4; d_i--;)
    {
        dd.rectI[d_i].visibility = dd.rectA[d_i].visibility = vis? 'show' : 'hide';
        if(vis) dd.rectI[d_i].zIndex = dd.rectA[d_i].zIndex = dd.z+2;
    }
};
dd.n4RectPos = function (d_o, d_x, d_y, d_w, d_h)
{
    d_o.x = d_x;
    d_o.y = d_y;
    d_o.clip.width = d_w;
    d_o.clip.height = d_h;
};
// NN4: Draw img sizing rect
dd.n4Rect = function (d_w, d_h)
{
    var d_i;
    if(!dd.rectI)
    {
        dd.rectI = new Array();
        dd.rectA = new Array();
    }
    if(!dd.rectI[0])
    {
        for(d_i = 4; d_i--;)
        {
            (dd.rectI[d_i] = new Layer(1)).bgColor = '#000000';
            (dd.rectA[d_i] = new Layer(1)).bgColor = '#ffffff';
        }
    }
    if(!dd.rectI[0].visibility || dd.rectI[0].visibility == 'hide') dd.n4RectVis(1);
    dd.obj.w = d_w;
    dd.obj.h = d_h;
    for(d_i = 4; d_i--;)
    {
        dd.n4RectPos(dd.rectI[d_i], dd.obj.x + (!(d_i-1)? (dd.obj.w-1) : 0), dd.obj.y + (!(d_i-2)? (dd.obj.h-1) : 0), d_i&1 || dd.obj.w, !(d_i&1) || dd.obj.h);
        dd.n4RectPos(dd.rectA[d_i], !(d_i-1)? dd.rectI[1].x+1 : (dd.obj.x-1), !(d_i-2)? dd.rectI[2].y+1 : (dd.obj.y-1), d_i&1 || dd.obj.w+2, !(d_i&1) || dd.obj.h+2);
    }
};
dd.reszTo = function (d_w, d_h)
{
    if(dd.n4 && dd.obj.is_image) dd.n4Rect(d_w, d_h);
    else dd.obj.resizeTo(d_w, d_h);
};
dd.embedVis = function (d_vis)
{
    var d_o = new Array('iframe', 'applet', 'embed', 'object');
    var d_i = d_o.length; while(d_i--)
    {
        var d_p = dd.ie? D.all.tags(d_o[d_i]) : D.getElementsByTagName? D.getElementsByTagName(d_o[d_i]) : null;
        if(d_p)
        {
            var d_j = d_p.length; while(d_j--)
            {
                var d_q = d_p[d_j];
                while(d_q.offsetParent || d_q.parentNode)
                {
                    if((d_q = d_q.parentNode || d_q.offsetParent || null) == dd.obj.div)
                    {
                        d_p[d_j].style.visibility = d_vis;
                        break;
                    }
                }
            }
        }
    }
};

dd.maxOffX = function (d_x, d_y)
{
    return(
        (dd.obj.maxoffl+1 && (d_y = dd.obj.defx-dd.obj.maxoffl)-d_x > 0
        || dd.obj.maxoffr+1 && (d_y = dd.obj.defx+dd.obj.maxoffr)-d_x < 0)? d_y
        : d_x
    );
};
dd.maxOffY = function (d_x, d_y)
{
    return(
        (dd.obj.maxofft+1 && (d_y = dd.obj.defy-dd.obj.maxofft)-d_x > 0
        || dd.obj.maxoffb+1 && (d_y = dd.obj.defy+dd.obj.maxoffb)-d_x < 0)? d_y
        : d_x
    );
};
dd.inWndW = function (d_x, d_y)
{
    var d_wx = dd.getScrollX(),
    d_ww = dd.getWndW();
    return(
        ((d_y = d_wx+2)-d_x > 0) || ((d_y = d_wx+d_ww+dd.obj.w-2)-d_x < 0)? d_y
        : d_x
    );
};
dd.inWndH = function (d_x, d_y)
{
    var d_wy = dd.getScrollY(),
    d_wh = dd.getWndH();
    return(
        ((d_y = d_wy+2)-d_x > 0) || ((d_y = d_wy+d_wh+dd.obj.h-2)-d_x < 0)? d_y
        : d_x
    );
};
// These two funcs limit the size of element when mouseresized.
// Implemented 22.5.2003 by Gregor Ltolf <[e-mail]>, modified by Walter Zorn
dd.limW = function (d_w)
{
    return(
        (dd.obj.minw-d_w > 0)? dd.obj.minw
        : (dd.obj.maxw > 0 && dd.obj.maxw-d_w < 0)? dd.obj.maxw
        : d_w
    );
};
dd.limH = function (d_h)
{
    return(
        (dd.obj.minh-d_h > 0)? dd.obj.minh
        : (dd.obj.maxh > 0 && dd.obj.maxh-d_h < 0)? dd.obj.maxh
        : d_h
    );
};

/**
 * Return vector (d:distance, a:angle, in degrees) from object center to mouse position
 */
dd.rotVect = function (o){
    var r={},cx=o.x+o.w/2,cy=o.y+o.h/2,dx=mouseX-cx,dy=mouseY-cy;
    r['d']=Math.sqrt(dx*dx+dy*dy);
    if(dx==0) {r['a']=90; if(dy>0) r['a']=-90;}
    else{
        r['a']=180*Math.atan(-dy/dx)/Math.PI;
        if(dx<0) r['a']+=180;
        if(r['a']>180) r['a']-=360;
    }
    return r;
}


// Optional autoscroll-page functionality. Courtesy Cedric Savarese.
// Implemented by Walter Zorn
function DDScroll()
{
    if(!dd.obj || !dd.obj.scroll && !dd.scroll || dd.ie4 || dd.whratio)
    {
        dd.scrx = dd.scry = 0;
        return;
    }
    var d_bnd = 0x1c,
    d_wx = dd.getScrollX(), d_wy = dd.getScrollY();
    if(dd.msmoved)
    {
        var d_ww = dd.getWndW(), d_wh = dd.getWndH(), d_y;
        dd.scrx = ((d_y = dd.e.x-d_ww-d_wx+d_bnd) > 0)? (d_y>>=2)*d_y
            : ((d_y = d_wx+d_bnd-dd.e.x) > 0)? -(d_y>>=2)*d_y
            : 0;
        dd.scry = ((d_y = dd.e.y-d_wh-d_wy+d_bnd) > 0)? (d_y>>=2)*d_y
            : ((d_y = d_wy+d_bnd-dd.e.y) > 0)? -(d_y>>=2)*d_y
            : 0;
    }
    if(dd.scrx || dd.scry)
    {
        W.scrollTo(
            d_wx + (dd.scrx = dd.obj.is_resized? dd.limW(dd.obj.w+dd.scrx)-dd.obj.w : dd.obj.vertical? 0 : (dd.maxOffX(dd.obj.x+dd.scrx)-dd.obj.x)),
            d_wy + (dd.scry = dd.obj.is_resized? dd.limH(dd.obj.h+dd.scry)-dd.obj.h : dd.obj.horizontal? 0 : (dd.maxOffY(dd.obj.y+dd.scry)-dd.obj.y))
        );
        dd.obj.is_dragged? dd.obj.moveTo(dd.obj.x+dd.getScrollX()-d_wx, dd.obj.y+dd.getScrollY()-d_wy)
            : dd.reszTo(dd.obj.w+dd.getScrollX()-d_wx, dd.obj.h+dd.getScrollY()-d_wy);
    }
    dd.msmoved = 0;
    W.setTimeout('DDScroll()', 0x33);
}
function PICK_CANCEL(d_ev){
    W.clearTimeout(dd.delayedPickTimeout);
    dd.delayedPickTimeout=0;
    dd.setUpHdl(dd.upFunc);
}
function PICK(d_ev)
{
    var par,offsetX,offsetY,delayedPick=0,o,n;
    if(dd.disabled) return true;

    // Resume delayed pick
    if(d_ev=='resume'){
        if(!dd.delayedPickTimeout) return;
        W.clearTimeout(dd.delayedPickTimeout);
        dd.delayedPickTimeout=0;
        dd.e=dd.delayedPickEvt;
        delayedPick=1;
    }
    else {
        updateMousePosition(d_ev);
        dd.e = new dd.evt(d_ev);
    }

    // Right-click: cancel (except for Opera, redirect to onrightclick function that has not been called by the oncontextmenu function)
    /*
    if(dd.e.button>1){
        if(dd.op && W.onrightclick) return onrightclick(d_ev);
        return false;
    }
    */

    if(dd.e.x >= dd.getWndW()+dd.getScrollX() || dd.e.y >= dd.getWndH()+dd.getScrollY()) return true; // on scrollbar

    var srcO,d_o, d_t, d_cmp = -1, d_i = dd.elements.length;

    // Try to find target with src property
    if(n=dd.e.src) while(1){
        if(n.id && (srcO=dd.elements[n.id])){
            break;
        }
        if(!n.parentNode||n.parentNode===n) break;
        n=n.parentNode;
    }

    while(d_i--){
        d_o = dd.elements[d_i];
        if(srcO && d_o!==srcO) continue;
        offsetX=offsetY=0;

        // Netscape : inlude parent's node scroll offset
        if(d_o.detachFromParent && (!dd.op)){
            par=d_o.div.parentNode;

            while(par && (!par.style || !par.style.overflow || par.style.overflow=='visible')) {
                if(par==par.parentNode) break;
                par=par.parentNode;
            }
            if(par){
                offsetY=par.scrollTop;
                offsetX=par.scrollLeft;
            }
        }
        if(dd.n4 && dd.e.but > 1 && dd.e.src == d_o.oimg && !d_o.clone) return false;
        if(srcO || (d_o.visible && dd.e.but <= 1 && dd.e.x >= d_o.x - offsetX && dd.e.x <= d_o.x+d_o.w-offsetX && dd.e.y >= d_o.y - offsetY && dd.e.y <= d_o.y+d_o.h - offsetY)) {
            if(d_o.z > d_cmp && (d_t = dd.e.src.tag).indexOf('inpu') < 0 && d_t.indexOf('texta') < 0 && d_t.indexOf('sele') < 0 && d_t.indexOf('opti') < 0 && d_t.indexOf('scrol') < 0 && (!dgi('maskDiv') || dgi('maskDiv').style.zIndex*1<d_o.z))
            {
                d_cmp = d_o.z;
                if(!d_o.frozen)    {
                    o=dd.obj = d_o;
                    o.offsetX=offsetX;o.offsetY=offsetY;
                }
            }
        }
    }

    if(o){
        // Start delayed pick
        if(o.pickDelay && !delayedPick){
            dd.delayedPickEvt = new dd.evt(d_ev);
            dd.setUpHdl(PICK_CANCEL);
            dd.delayedPickTimeout=W.setTimeout('PICK("resume")',o.pickDelay);
            o=dd.obj=null;
            return false;
        }
        if(o.isWindow) win(o.name).select();

        // Add "dragged" to class
        if(o.dragClass) $(o.div).e.className().add('dragged');

        if(o.nodrag) o=dd.obj = null;
        else {
            // Store mouse coordinates
            o.mPickX=mouseX; o.mPickY=mouseY;

            if(o.rot){
                // store object center coordinates
                o.cPickX=o.x+o.w/2; o.cPickY=o.y+o.h/2;

                // store object source width & height
                o.pickW=o.w; o.pickH=o.h;

                // store object actual css rotation
                var s=o.div.style,r=(s.MozTransform||s.WebkitTransform||s.OTransform)
                o.lpa=o.angle=o.pickAngle=(r&&r.indexOf)?-1*(r.substring(r.indexOf('(')+1,r.indexOf('d'))):0;

                // Store center-mouse vector angle and length
                o.pickRotVect=dd.rotVect(o);
            }


            var d_rsz = (dd.e.modifKey || dd.e.ctrlKey) && (o.resizable || o.scalable);
            if(dd.op)
            {
                (d_o = dgi('OpBlUr')).style.pixelLeft = dd.e.x;
                d_o.style.pixelTop = dd.e.y;
                (d_o = d_o.children[0].children[0]).focus();
                d_o.blur();
            }
            else if(dd.ie && !dd.ie4)
            {
                if(D.selection && D.selection.empty) D.selection.empty();
                dd.db.onselectstart = function ()
                {
                    event.returnValue = false;
                };
            }
            if(d_rsz || o.resizeIfPick || o.resizableOnly)
            {

                if(!o.isWindow) {
                    if(o.minh==o.maxh) o._setCrs('e-resize');
                    else {
                        if(o.minw==o.maxw) o._setCrs('s-resize'); else o._setCrs('se-resize');
                    }
                }
                if(o.isWindow) {
                    if(dd.op) win(o.name).resizeMask();
                    //if(dd.op) dgi(o.name+"_mask").style.height=dgi(o.name+"_if").style.height;
                    dgi(o.name+"_mask").style.display="block";
                }
                o.is_resized = 1;
                dd.whratio = o.scalable? o.defw/o.defh : 0;
                if(dd.ie)
                {
                    if(dd.ie4)
                    {
                        W.dd_x = dd.getScrollX();
                        W.dd_y = dd.getScrollY();
                    }

                    setTimeout(
                        'if(dd.obj && D.selection && D.selection.empty)'+
                        '{D.selection.empty();if(dd.ie4) W.scrollTo(W.dd_x, W.dd_y);}',0);
                }
                dd.setMovHdl(RESIZE);
                dd.reszTo(o.w, o.h);
            }
            else
            {

                o.is_dragged = 1;
                if(o.isWindow) {
                    //if(dd.op) dgi(o.name+"_mask").style.width=dgi(o.name+"_if").style.width;
                    if(dd.op) dgi(o.name+"_mask").style.height=dgi(o.name+"_if").offsetHeight + " ";
                    dgi(o.name+"_mask").style.display="block";
                }
                dd.setMovHdl(DRAG);
            }

            dd.setUpHdl(DROP);
            if(!o.isWindow) dd.embedVis('hidden');
            o._setOpaRel(0.7);
            o.maximizeZ();
            dd.ofx = o.x+o.w-dd.e.x;
            dd.ofy = o.y+o.h-dd.e.y;

            o.pickMouseX=mouseX;o.pickMouseY=mouseY;
            o.pickX=o.lpx=o.x;o.pickY=o.lpy=o.y;o.lpdx=0;o.lpdy=0;o.lpdt=0;
            o.pickDate=o.lpDate=(new Date()).getTime();

            my_PickFunc();
            if(o.pickFunc) o.pickFunc();
            DDScroll();

            return !(
                o.is_resized
                || dd.n4 && o.is_image
                || dd.n6 || dd.w3c
            );
        }
    }

    if(dd.downFunc) return dd.downFunc(d_ev);
    return true;
}

function DRAG(d_ev)
{
    var o=dd.obj;
    if(dd.disabled) return true;
    updateMousePosition(d_ev);

    if(!o || !o.visible) return true;
    o.resizeIfPick=false;
    if(dd.ie4 || dd.w3c || dd.n6 || o.children.length > 0xf)
    {
        if(dd.wait) return false;
        dd.wait = 1;
        setTimeout('dd.wait = 0;', dd.tiv);
    }
    dd.e = new dd.evt(d_ev);

    if(dd.ie && !dd.e.but)
    {
        DROP(d_ev);
        return true;
    }

    dd.msmoved = 1;

    // Window or icon dragged: use desktop padding for boundaries
    if(o.isWindow || o.isIcon){
        var p=dd.getPadding(),
        nx=Math.max(p.left,dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-o.w)),
        ny=Math.max(p.top,dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-o.h));

        if(W.winLimitArea!==0){
            nx=Math.min(nx,dd.getWndW()-o.w-p.right);
            ny=Math.min(ny,dd.getWndH()-o.h-p.bottom);
        }
        o.moveTo(o.vertical? o.x : nx, o.horizontal? o.y : ny);
    }

    // If object has rotation, use a special drag&rotate function
    else if(o.rot && o.pickRotVect['d']>o.w/4){
        var nV=dd.rotVect(o),a=Math.PI*(nV['a']+180)/180,d=o.pickRotVect['d'];
        o.moveTo(mouseX+d*Math.cos(a)-o.w/2,mouseY-d*Math.sin(a)-o.h/2)
        o.rotTo(o.pickAngle+nV['a']-o.pickRotVect['a'])
    }
    else
        if(o.detachFromParent) o.moveTo(
        - o.offsetX + (o.detachOffsetX?o.detachOffsetX:0) + (o.vertical? o.x : dd.ofx+dd.e.x-o.w),
        - o.offsetY + (o.detachOffsetY?o.detachOffsetY:0) + (o.horizontal? o.y : dd.ofy+dd.e.y-o.h));
        else o.moveTo(
        - o.offsetX + (o.detachOffsetX?o.detachOffsetX:0) + (o.vertical? o.x : dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-o.w)),
        - o.offsetY + (o.detachOffsetY?o.detachOffsetY:0) + (o.horizontal? o.y : dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-o.h))        );
    if(o.maxXPos && o.x>o.maxXPos) o.moveTo(o.maxXPos,false);
    if(o.minXPos && o.x<o.minXPos) o.moveTo(o.minXPos,false);
    if(o.mayYPos && o.y>o.mayYPos) o.moveTo(o.mayYPos,false);
    if(o.minYPos && o.y<o.minYPos) o.moveTo(o.minYPos,false);
    my_DragFunc();

    if(o.dragFunc) {
        if(typeof o.dragFunc=='string') eval (o.dragFunc+'()'); else o.dragFunc();
    }
    return MOUSE_MOVED(d_ev);
}

function RESIZE(d_ev)
{
    var o=dd.obj;
    updateMousePosition(d_ev);
    if(!o || !o.visible) return true;
    if(dd.wait) return false;
    dd.wait = 1;
    setTimeout('dd.wait = 0;', dd.tiv);
    dd.e = new dd.evt(d_ev);

    if(dd.ie && !dd.e.but)
    {
        DROP(d_ev);
        return true;
    }
    dd.msmoved = 1;
    if(o.isWindow){
        var p=dd.getPadding();
        var d_w, d_h;
        var prevW=o.w;
        var prevH=o.h;
        if(o.resizeDir=="l" || o.resizeDir=="tl" || o.resizeDir=="bl"){
            if((d_w = dd.limW(2*dd.ofx-(dd.inWndW(dd.ofx+dd.e.x)-o.x)))!=prevW){
                if(dd.e.x<p.left) {d_w-=p.left-dd.e.x;dd.e.x=p.left}
                if(dd.e.y<p.top) {d_h-=p.top-dd.e.y;dd.e.y=p.top}
                o.moveTo(dd.e.x,o.y);
                dd.ofx = o.x+d_w-dd.e.x;
            }
        }
        else if (o.resizeDir=="r" || o.resizeDir=="tr" || o.resizeDir=="br"){
            d_w = dd.limW(dd.inWndW(dd.ofx+dd.e.x)-o.x);
        }
        else var d_w = o.w;

        if(o.resizeDir=="tl" || o.resizeDir=="t" || o.resizeDir=="tr"){
            if((d_h = dd.limH(2*dd.ofy-(dd.inWndH(dd.ofy+dd.e.y)-o.y)))!=prevH){
                o.moveTo(o.x,dd.e.y);
                dd.ofy = o.y+d_h-dd.e.y;
            }
        }
        else if (o.resizeDir=="br" || o.resizeDir=="b" || o.resizeDir=="bl"){
            d_h = dd.limH(dd.inWndH(dd.ofy+dd.e.y)-o.y);
        }
        else d_h = o.h;
        d_w=Math.min(d_w,dd.getWndW()-p.right-o.x)
        d_h=Math.min(d_h,dd.getWndH()-p.bottom-o.y)

        // Prevent 0 width or height for windows
        if(d_w<=0) d_w=false; if(d_h<=0) d_h=false;
    }
    // If object has rotation, stretch and rotate according to difference between current center->mouse vector and pick cener->mouse vector
    else if(o.rot){
        var f,nV=dd.rotVect(o);
        f=nV['d']/o.pickRotVect['d'];
        o.resizeTo(f*o.pickW,f*o.pickH)
        o.moveTo(o.pickX-(o.w-o.pickW)/2, o.pickY-(o.h-o.pickH)/2)
        o.rotTo(o.pickAngle+nV['a']-o.pickRotVect['a'])
    }
    else{
        var d_w = dd.limW(dd.inWndW(dd.ofx+dd.e.x)-o.x), d_h;
        if(!dd.whratio) d_h = dd.limH(dd.inWndH(dd.ofy+dd.e.y)-o.y);
        else
        {
            d_h = dd.limH(dd.inWndH(Math.round(d_w/dd.whratio)+o.y)-o.y);
            d_w = Math.round(d_h*dd.whratio);
        }
    }
    // Do resize (except if rot, resi
    if(!o.rot) dd.reszTo(d_w, d_h);
    if(W.my_ResizeFunc) my_ResizeFunc();
    if(o.resizeFunc) o.resizeFunc();
    return MOUSE_MOVED(d_ev);
}

// Script load monitoring
if(W.lFunc) lFunc('wz_dragdrop',25);

/**
 * DROP FUNCTION
 */
function DROP(d_ev)
{
    if(dd.disabled) return true;
    if(d_ev){
        dd.e = new dd.evt(d_ev);
        updateMousePosition(d_ev);
    }

    var o=dd.obj;
    if(o){
        // Set drag time (overwritten when object stops if inertia)
        o.dragTime=(new Date()).getTime()-o.pickDate;
        // Store mouse coordinates
        o.mDropX=mouseX; o.mDropY=mouseY;
        o.mdx=o.mDropX-o.mPickX; o.mdy=o.mDropY-o.mPickY;

        if(o.is_dragged)
        {
            if(!o.is_image) dd.getWH(o);
        }
        else if(dd.n4)
        {
            if(o.is_image)
            {
                dd.n4RectVis(0);
                o.resizeTo(o.w, o.h);
            }
        }


        dd.setMovHdl(MOUSE_MOVED);
        //dd.setMovHdl(OVER);
        dd.setUpHdl(dd.upFunc);
        if(dd.db) dd.db.onselectstart = null;
        o._setOpaRel(1.0);
        o._setCrs(o.cursor);
        if(!o.isWindow) dd.embedVis('visible');
        o._resetZ();
        if(d_ev) dd.e = new dd.evt(d_ev);
        my_DropFunc();

        if(o.dropFunc) o.dropFunc();
        dd.msmoved = o.is_dragged = o.is_resized = dd.whratio = 0;

        dd.obj = null;
    }

    dd.setDwnHdl(PICK);
}
function KDOWN(d_e){
    updateMousePosition(d_e);
    if(dragInProgress && dd.obj && dd.obj.ctrlPlus) my_DragFunc();
    if(dd.kDwnFunc) return dd.kDwnFunc(d_e);
}
function KUP(d_e){
    updateMousePosition(d_e);
    if(dragInProgress && dd.obj && dd.obj.ctrlPlus) my_DragFunc();
    if(dd.kUpFunc) return dd.kUpFunc(d_e);
}

// Function called on drag event
function MOUSE_MOVED(d_e){
    if(dd.disabled) return true;
    // Update mouseX and mouseY coordinates
    updateMousePosition(d_e);

    // Delayed object PICK management
    if(dd.delayedPickTimeout){
        if(Math.abs(dd.delayedPickEvt.x-mouseX)+Math.abs(dd.delayedPickEvt.y-mouseY)>2) return PICK('resume');
    }
    // if D.onmousemove function set, call it
    if(dd.moveFunc) return dd.moveFunc(d_e); else return bBrowser=='iPhone';
}
function SET_DHTML()
{
    dd.moveFunc = D.onmousemove;
    D.onmousemove=MOUSE_MOVED;
    D.ontouchmove=MOUSE_MOVED; // iPhone
    var d_a = arguments, d_ai, d_htm = '', d_o, d_i = d_a.length; while(d_i--)
    {
        if(!(d_ai = d_a[d_i]).indexOf('c:')) dd.cursor = d_ai.substring(2);
        else if(d_ai == NO_ALT) dd.noalt = 1;
        else if(d_ai == SCROLL) dd.scroll = 1;
        else if(d_ai == RESET_Z) dd.re_z = 1;
        else if(d_ai == RESIZABLE) dd.resizable = 1;
        else if(d_ai == SCALABLE) dd.scalable = 1;
        else if(d_ai == TRANSPARENT) dd.diaphan = 1;
        else
        {
            d_o = new DDObj(d_ai);
            dd.addElt(d_o);
            d_htm += d_o.t_htm || '';
            if(d_o.oimg && d_o.cpy_n)
            {
                var d_j = 0; while(d_j < d_o.cpy_n)
                {
                    var d_p = new DDObj(d_o.name+d_o.cmd, ++d_j);
                    dd.addElt(d_p, d_o);
                    d_p.defz = d_o.defz+d_j;
                    d_p.original = d_o;
                    d_htm += d_p.t_htm;
                }
            }
        }
    }
    if (dd.n4 || dd.n6 || dd.ie || dd.op || dd.w3c) D.write(
        (dd.n4? '<div style="position:absolute;"><\/div>\n'
        : (dd.op && !dd.op6)? '<div id="OpBlUr" style="position:absolute;visibility:hidden;width:0px;height:0px;"><form><input type="text" style="width:0px;height:0px"><\/form><\/div>'
        : '') + d_htm
    );
    dd.zMin = dd.z = 100;
    d_i = dd.elements.length; while(d_i--)
    {
        dd.addProps(d_o = dd.elements[d_i]);
        if(d_o.is_image && !d_o.original && !d_o.clone)
            dd.n4? d_o.oimg.src = spacer : d_o.oimg.style.visibility = 'hidden';
    }

    dd.mkWzDom();
    if(W.onload) dd.loadFunc = W.onload;
    if(W.onunload) dd.uloadFunc = W.onunload;
    W.onload = dd.initz;
    W.onunload = dd.finlz;
    dd.setDwnHdl(PICK);
    dd.setKDwnHdl(KDOWN);
    dd.setKUpHdl(KUP);
    if(!W.isMainFrame&&W.phpBrowser=='gecko') {if(D.body.onmouseout) bodyOnMouseout=D.body.onmouseout;D.body.onmouseout=my_bodyOut;}
}
function ADD_DHTML(d_o,noMkWzDom) // layers only!
{
    d_o = new DDObj(d_o);
    dd.addElt(d_o);
    dd.addProps(d_o);
    if(!noMkWzDom) dd.mkWzDom();
}




////////////////////////////////////////////////////////////
// If not needed, all code below this line may be removed


// For backward compatibility
dd.d = document;            // < v. 2.72
var RESET_ZINDEX = RESET_Z; // < 3.44
var KEYDOWN_RESIZE = RESIZABLE; // < 4.43
var CURSOR_POINTER = CURSOR_HAND; // < 4.44
var NO_SCROLL = '';         // < v. 4.49




////////////////////////////////////////////////////////////
// FUNCTIONS FOR EXTENDED SCRIPTING
// Use these for your own extensions,
// or to call functions defined elsewhere



/* my_PickFunc IS AUTOMATICALLY CALLED WHEN AN ITEM STARTS TO BE DRAGGED.
The following objects/properties are accessible from here:

- dd.e: current mouse event
- dd.e.property: access to a property of the current mouse event.
  Mostly requested properties:
  - dd.e.x: document-related x co-ordinate
  - dd.e.y: document-related y co-ord
  - dd.e.src: target of mouse event (not identical with the drag drop object itself).
  - dd.e.button: currently pressed mouse button. Left button: dd.e.button <= 1

- dd.obj: reference to currently dragged item.
- dd.obj.property: access to any property of that item.
- dd.obj.method(): for example dd.obj.resizeTo() or dd.obj.swapImage() .
  Mostly requested properties:
    - dd.obj.name: image name or layer ID passed to SET_DHTML();
    - dd.obj.x and dd.obj.y: co-ordinates;
    - dd.obj.w and dd.obj.h: size;
    - dd.obj.is_dragged: 1 while item is dragged, else 0;
    - dd.obj.is_resized: 1 while item is resized, i.e. if <ctrl> or <shift> is pressed, else 0

For more properties and details, visit the API documentation
at http://www.walterzorn.com/dragdrop/api_e.htm (english) or
http://www.walterzorn.de/dragdrop/api.htm (german)    */
function my_PickFunc()
{
    var o=dd.obj;
    if(winInertiaTimeout) W.clearTimeout(winInertiaTimeout);
    winInertiaTimeout=false;

    if(tooltipShown) tooltipDestroy();

    dragInProgress=true;

    /* out of overflow:scroll/hidden div */
    if(o.detachFromParent) {
        var node=o.div;
        var tmpDragNode=node.cloneNode(true); // clone staying at node's original location
        tmpDragNode.setAttribute('id','tmpDragNode');
        tmpDragNode.style.visibility='hidden';
        node.parentNode.insertBefore(tmpDragNode,node);
        // attach item to body or to dragDetach item
        if(!dgi('dragDetach')) {
            var ddNode=D.createElement("div");
            ddNode.id="dragDetach";
            ddNode.style.position="absolute";ddNode.style.top=0;ddNode.style.left=0;ddNode.style.zIndex=10000;
            D.body.appendChild(ddNode);
        }
        dgi('dragDetach').appendChild(node);
        dd.recalcItem(o.name);
    }

    if(W.preDrag) {if(!preDrag()) return;}

    if(o.isWindow) winPicked();

    // Check onpick property of dragged item
    for(var i=0;i<o.div.attributes.length;i++) {
        if(o.div.attributes[i].name.toLowerCase()=='onpick') eval(o.div.attributes[i].value);
    }

    dragCancelOnclick=false;

    if(o.detachFromParent) o.moveTo(
        o.detachOffsetX + (o.vertical? o.x : dd.ofx+dd.e.x-o.w)- o.offsetX,
         o.detachOffsetY + (o.horizontal? o.y : dd.ofy+dd.e.y-o.h)- o.offsetY
    );
    else o.moveTo(
        o.detachOffsetX + (o.vertical? o.x : dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-o.w))- o.offsetX,
         o.detachOffsetY + (o.horizontal? o.y : dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-o.h))- o.offsetY
    );
    // Recompute rect of receiverOnly objects
    drec.computeRect();
}

/* my_DragFunc IS CALLED WHILE AN ITEM IS DRAGGED
See the description of my_PickFunc above for what's accessible from here. */
function my_DragFunc(launchedItem){
    var nt=(new Date()).getTime(),bounceCushion=3,gravity=0,padding=W.winPadding;
    var o=dd.obj;
    if(!launchedItem){
        o.lpdx=o.x-o.lpx;
        o.lpdy=o.y-o.lpy;
        o.lpda=o.angle-o.lpa;
        o.lpx=o.x;o.lpy=o.y;o.lpa=o.angle;
        if(nt>o.lpDate) o.lpdt=nt-o.lpDate;
        o.lpDate=nt;
        if(mouseEvt.e.ctrlKey && o.ctrlPlus) {
            if(!dd.elements.ctrlPlusItem){
                var ctrlPlusItem=D.createElement("div");
                ctrlPlusItem.id='ctrlPlusItem';
                ctrlPlusItem.style.position='absolute';
                ctrlPlusItem.innerHTML='<img alt="" src="/gfx/plus.gif">';
                D.body.appendChild(ctrlPlusItem);
                ADD_DHTML('ctrlPlusItem');
            }
            dd.elements.ctrlPlusItem.show();
            //dd.elements.ctrlPlusItem.moveTo(o.x-4,o.y-4)
            dd.elements.ctrlPlusItem.moveTo(o.x-12,o.y-12)
        }
        else if(o.ctrlPlus && dd.elements.ctrlPlusItem) dd.elements.ctrlPlusItem.hide();
    }
    // Launched item
    else{
        var b;
        if(dd.elements[launchedItem]==null) return;

        b=W.dragNLaunchFriction||0.005;

        prevObj=o;
        o=dd.obj=dd.elements[launchedItem];

        // If object or all objects may not be launched, abort
        if(!o.isLaunched && (o.noLaunch || dd.noLaunch)) return;

        o.isLaunched=1;


        if(o.lpdt==0){o.lpdt=1;    o.lpdx=0; o.lpdy=0;}

        // Scene borders
        var minX=0; if(o.maxoffl!=-1) minX=Math.max(0,o.defx-o.maxoffl);
        var maxX=(W.winMe)?winMe.getInnerWidth():D.body.scrollWidth; if(o.maxoffr!=-1) maxX=o.defx+o.maxoffr+o.w;
        var minY=0; if(o.maxofft!=-1) minY=Math.max(0,o.defy-o.maxofft);
        var maxY=(W.winMe)?winMe.getInnerHeight():D.body.scrollHeight; if(o.maxoffb!=-1) maxY=o.defy+o.maxoffb;

        if(padding){
            minX+=padding['left'];
            maxX-=padding['right'];
            minY+=padding['top'];
            maxY-=padding['bottom'];
        }

        // Gravity
        o.lpdy+=gravity*o.lpdt;

        // speeds
        var vx=(o.lpdx/o.lpdt);
        var vy=(o.lpdy/o.lpdt);
        var va=(o.lpda/o.lpdt);
        var dt=nt-o.lpDate; o.lpDate+=dt;

        var dv=Math.exp(-1.0*b*dt)
        o.lpdx*=dv;
        o.lpdy*=dv;
        o.lpda*=dv;

        var dx=vx*(1-dv)/b;
        var dy=vy*(1-dv)/b+gravity*dt;

        var nx=o.lpx+dx;
        var ny=o.lpy+dy;

        // Bounce
        var prc=1;
        if(o.bounce && (nx<minX || nx+o.w>maxX)){
            if(nx<minX) prc=(minX-o.lpx)/dx; else prc=(maxX-o.lpx-o.w)/dx;
            prc=(prc+(1-prc)/bounceCushion);
            dx*=prc; dy*=prc;
            if(nx<minX) nx=2*minX-(o.lpx+dx); else nx=nx=2*maxX-(o.lpx+dx)-2*o.w;
            ny=o.lpy+dy;
            o.lpdx=-o.lpdx/bounceCushion;
            o.lpdy=o.lpdy/bounceCushion;
            if(o.rot) o.lpda+=o.lpdy;
        }
        if(o.bounce && (ny<minY || ny+o.h>maxY)){
            if(ny<minY) prc=(minY-o.lpy)/dy; else prc=(maxY-o.lpy-o.h)/dy;
            prc=(prc+(1-prc)/bounceCushion);
            dy*=prc; dx*=prc;
            if(ny<minY) ny=2*minY-(o.lpy+dy); else ny=ny=2*maxY-(o.lpy+dy)-2*o.h;
            nx=o.lpx+dx;
            o.lpdy=-o.lpdy/bounceCushion;
            o.lpdx=o.lpdx/bounceCushion;
            if(o.rot) o.lpda-=o.lpdx;
        }

        o.lpx=nx;
        o.lpy=ny;
        o.moveTo(nx,ny);
        if(o.rot && o.lpda) o.rotBy(o.lpda);
        dd.elements[launchedItem]=o;
    }
    if(W.duringDrag) duringDrag();


    if(wl) wl.autoScrollDivs.check();
    if(o.notDroppable) return;

    var dropTarget=null,receiverOnlyTarget;
    if(!(receiverOnlyTarget=o.receiverOnlyGetEltBelow(0,1))) dropTarget = o.getEltBelow();

    /* unhighlight drop target */
    if(cDT!=null && cDT!=dropTarget){
        if(cDT.transparentReceiver) cDT.setOpacity(1); else cDT.div.className="dropTarget";
        cDT=null;
    }
    /* unhighlight receiver only target */
    if(drec.currentTarget!=null && drec.currentTarget!=receiverOnlyTarget) drec.unhighlight();

    /* highlight drop target */
    if(dropTarget != null && dropTarget.receiver && !cDT && o!=dropTarget) {
        cDT=dropTarget;
        if(cDT.transparentReceiver) cDT.setOpacity(0.5);
        else cDT.div.className="dropTargetOver";
    }
    /* highlight receiver-only target */
    if(receiverOnlyTarget != null && receiverOnlyTarget!=drec.currentTarget) drec.highlight(receiverOnlyTarget);

    if(launchedItem){
        // reset drag time
        o.dragTime=(new Date()).getTime()-o.pickDate;
        if(Math.abs(vx)<0.03 && Math.abs(vy) <0.03) o.isLaunched=0;
        var va=o.lpda; if(isNaN(va)) va=0;
        o=dd.obj=prevObj;

        // Launched item stops
        if(Math.abs(vx)<0.03 && Math.abs(vy) <0.03 && Math.abs(va)<1) my_DropFunc(launchedItem);
        else winInertiaTimeout=W.setTimeout('my_DragFunc("'+launchedItem+'")', 20);
    }
}




/* my_ResizeFunc IS CALLED WHILE AN ITEM IS RESIZED
See the description of my_PickFunc above for what's accessible from here. */
function my_ResizeFunc(){
    var o=dd.obj;
    resizeInProgress=true;
    if(o.isWindow){
        if(o.w>dd.getWndW() || o.h>dd.getWndH()){
            o.resizeTo(Math.min(o.w>dd.getWndW()),Math.min(o.h>dd.getWndH()));
        }
        if(o.x<0 || o.y<0) o.moveTo(Math.max(0,o.x), Math.max(0,o.y));
        win(o.name).resizeMask();
    }
}
/* Called on resize complete */
function my_ResizedFunc(){if(W.resizeComplete) resizeComplete();}

/* THIS ONE IS CALLED ONCE AN ITEM IS DROPPED
See the description of my_PickFunc for what's accessible from here.
Here may be investigated, for example, what's the name (dd.obj.name)
of the dropped item, and where (dd.obj.x, dd.obj.y) it has been dropped... */
function my_DropFunc(launchedItem)
{
    var o=dd.obj;
    if(dd.elements.ctrlPlusItem) dd.elements.ctrlPlusItem.hide();
    drec.unhighlight();
    if(!o || o.inertia){
        if(!launchedItem){
            var dt=((new Date()).getTime() - o.lpDate);
            if(dt < ((W.dragNLaunchThreshold!=undefined)?dragNLaunchThreshold:100) && o.lpdt>0){ // start launch
                dragCancelOnclick=true;
                my_DragFunc(o.index);
                return;
            }
        }
        else{
            prevObj=dd.obj;
            o=dd.obj=dd.elements[launchedItem];
            dragCancelOnclick=false;
        }
    }

    /* out of overflow:scroll/hidden div */
    if(o.detachFromParent) {
        dgi('tmpDragNode').parentNode.insertBefore(o.div,dgi('tmpDragNode'));
        dgi('tmpDragNode').parentNode.removeChild(dgi('tmpDragNode'));
        dd.recalcItem();o.moveTo(o.vertical? o.x : dd.maxOffX(dd.inWndW(dd.ofx+dd.e.x)-o.w),o.horizontal? o.y : dd.maxOffY(dd.inWndH(dd.ofy+dd.e.y)-o.h));
    }

    dragInProgress=false;
    if(resizeInProgress) my_ResizedFunc()
    resizeInProgress=false;

    var DTClass;
    if(o.dragTime > dragMinTimeForPreDrop && W.preDrop) preDrop();
    if(o.div.onmouseout) o.div.onmouseout();

    // Restore class
    if(o.dragClass) $(o.div).e.className().remove('dragged');

    // Check ondrop property of dragged item
    if(Math.pow(o.x - o.defx,2) + Math.pow(o.y - o.defy, 2) > 0){
        for(i=0;i<o.div.attributes.length;i++) {
            if(o.div.attributes[i].name.toLowerCase()=='ondrop') eval(o.div.attributes[i].value);
        }
    }
    if(o.isWindow) winDropped();
    if(o.isIcon) iconDropped();

    // Get drop target
    var dropTarget = null, receiverOnlyTarget=null;
    if(W.dropFunction && !o.notDroppable)
        if(!(receiverOnlyTarget=o.receiverOnlyGetEltBelow())) dropTarget=o.getEltBelow();

    // Drag distance
    var d2;
    if(o.inertia)
        d2=Math.pow(o.x - o.pickX,2) + Math.pow(o.y - o.pickY, 2);
    else
        d2=Math.pow(o.mdx,2) + Math.pow(o.mdy, 2);

    /**
     * Check if dropped over a target
     */
    if(W.dropFunction!=false && !o.notDroppable && o.dragTime > 300 && d2>20){
        // If a droppable object is dropped over a receiver (drop target) and a drop function has been defined, launch drop function
        if(dropTarget && dropTarget.receiver) {
            if(o.name.substr(0,1)=='_') eval('W.dropFunction("'+o.name.substr(1)+'", "'+dropTarget.name+'");');
            else eval('W.dropFunction("'+o.name+'", "'+dropTarget.name+'");');
        }
        // Correct a z-index bug (or implementation issue ?)
        else if(cDT && cDT.receiver){
            if(o.name.substr(0,1)=='_') eval('W.dropFunction("'+o.name.substr(1)+'", "'+cDT.name+'");');
            else eval('W.dropFunction("'+o.name+'", "'+cDT.name+'");');
        }
        // else if a receiverOnly target is found
        else if(receiverOnlyTarget && receiverOnlyTarget.id){
            if(o.name.substr(0,1)=='_') eval('W.dropFunction("'+o.name.substr(1)+'", "'+receiverOnlyTarget.id+'");');
            else eval('W.dropFunction("'+o.name+'", "'+receiverOnlyTarget.id+'");');
        }
    }

    var srcObj;
    if(o.is_image)
        srcObj=D.getElementsByName(o.name)[0];
    else
        srcObj=dgi(o.name);

    // if object not moved, do click if onclick attribute
    if((d2 < 65 && (o.dragTime < 350)) || (o.dragTime < 100)){
        dd.dragClick=1;
        dragCancelOnclick=0;
        if(srcObj && srcObj.attributes['onclick']) eval(srcObj.attributes['onclick'].nodeValue);
        dd.dragClick=0;
    }
    else{
        if(!o.is_image && srcObj && srcObj.attributes['onclick']) dragCancelOnclick=true;
    }
    /* un-highlight drop target */
    if(cDT!=null){
        if(cDT.transparentReceiver) cDT.setOpacity(1); else cDT.div.className="dropTarget";
        cDT=null;
    }

    // Return to position
    if(o.elastic || o.elasticTmp){
        o.elasticTmp=0;
        // Animation
        if(!o.noAnim && !o.cancelAnim) {
            dd.elasticAnim(o.name);
        }
        // No animation
        else {
            if(o.cancelAnim) o.cancelAnim=0;
            o.moveTo(o.defx, o.defy);
            dd.recalcItem();
            o.released();
        }
    }
    else {
        o.defx=o.x;o.defy=o.y;
        dd.recalcItem();
        o.released();
    }

    //
    if(o.dropFuncInertia) o.dropFuncInertia();

    // Reset previous o
    if(launchedItem) dd.obj=prevObj;
}

function my_DragClearAllItems(){
    while(dd.elements.length>0) dd.elements[0].del(true);
    dd.recalc();
}

function my_winResize(){if(W.bodyResized) bodyResized();}

// Update mouseX and mouseY coordinates
function updateMousePosition(d_e){
    var dt,newT;
    //if(this.t==undefined) alert('u')
    mouseEvt = new dd.evt(d_e);
    if(mouseEvt.x || mouseEvt.y){
        newT=wl.chrono.microtime();

        if(mousePosT!=undefined){
            //dgi('debug').innerHTML=newT-mousePosT;
            if(dt=(newT-mousePosT)){
                mouseVX=1000*(mouseEvt.x-mouseX)/dt
                mouseVY=1000*(mouseEvt.y-mouseY)/dt
            }
        }
        else{
            mouseVX=mouseVY=0;
        }
        mousePosT=newT;
        mouseX=mouseEvt.x;
        mouseY=mouseEvt.y;
    }
}
// Monitor mouse position even outside of drag & drop events
function monitorMousePosition(){D.onmousemove=updateMousePosition}
var bodyOnMouseout=0;
function my_bodyOut(){
    /*
    if(bodyOnMouseout) bodyOnMouseout;
    if(dragInProgress && dd.obj && !(dd.scroll || dd.obj.scroll)) DROP(false);
    */
}

// Script load monitoring
if(W.lFunc) lFunc('wz_dragdrop',25);